A bitbybit::bitfield struct may be easier to use here.

hmm, that need is covered by the L1Section. This is more of a high-level attribute collection which also abstracts the various bits into their high-level meaning. Maybe a section_attribute method for the L1 section would be better? It does a lot of stuff usually covered by bitbybit though, admittedly..

It just seems unnecessary to have to do all the shifting manually.

Perhaps you could have a public type which is normal, and a private type that is a bitbybit bitfield, and an Into impl to convert between them. Then you can let bitfield macro do the hard work, but it's not in the public API.

What do you think about adding this API for the L1 section:

    #[inline]
    pub fn section_attrs(&self) -> Result<SectionAttributes, InvalidL1EntryType> {
        SectionAttributes::from_raw(self.raw_value())
    }

    #[inline]
    pub fn set_section_attrs(&mut self, section_attrs: SectionAttributes) {
        self.raw_value = self.base_addr().as_u32() | section_attrs.raw();
    }

okay, I'll have a look at bitbybit to avoid the boilerplate bit shifting

Uh, maybe? I don't have a good handle on how this API is used.

I'll figure out something that makes sense :)

okay, I updated the API. Less bitshifting, and it is actually a lot better from a user perspective as well.

worrying that I just found this because I wanted to add a builder..

explicit PR for this bugfix: #45

okay, I updated the API. Less bitshifting, and it is actually a lot better from a user perspective as well.

Same as above: I could also write this using the builder API. It would be very verbose, but shouldn't matter for performance.

I could also write this using the builder API. It would be very verbose, but shouldn't matter for performance.

    /// Set the section attributes without changing the address.
    #[inline]
    pub fn set_section_attrs(&mut self, section_attrs: SectionAttributes) {
        let attrs = section_attrs.l1_section_part();
        *self = L1Section::builder()
            .with_base_addr(self.base_addr())
            .with_ng(attrs.ng())
            .with_s(attrs.s())
            .with_apx(attrs.apx())
            .with_tex(attrs.tex())
            .with_ap(attrs.ap())
            .with_p_bit(attrs.p_bit())
            .with_domain(attrs.domain())
            .with_xn(attrs.xn())
            .with_c(attrs.c())
            .with_b(attrs.b())
            .with_entry_type(attrs.entry_type())
            .build()
    }

to be honest, I prefer the first one..